The Compiler supports new syntax that allows local variable declaration in a block and improves the declaration of parameters in Method-ID for Object Oriented Programming. Java classes with generic types can now be declared with a specific type, simplifying the casting using the syntax “< >”. Also, concatenation using the “&” operator has been improved.

Many languages such as C# and Java support local variable declaration syntax to create a variable in a specific method or code block. This has several advantages, including:

The newest isCOBOL compiler implements the local variable declaration with the new DECLARE statement.

The DECLARE statement declares one or more local variables within the Procedure Division body. The scope of any inline local variable is from the point of declaration until the end of the innermost containing block. Statement clauses, paragraphs, sections and the whole method are considered to be blocks. The type of variable can be a primitive type, a java class object or any COBOL picture declared under a TYPEDEF clause. A code snippet like:

shows the temp variable declared in two different blocks; the first inside the IF where the variable is declared as java.lang.String, the other inside the ELSE where the variable is declared as “pic 9(9) comp” that is the picture used in the assigned TYPEDEF.

The Compiler supports a new syntax to define method parameters directly in the METHOD-ID paragraph, without using the Linkage Section and the USING clause after PROCEDURE DIVISION. This is typically useful in class-id with many methods that receive and return parameters. It’s now possible to specify the method signature directly in the METHOD-ID. A code like:

is equivalent to this:

The advantage is shorter code and a source that looks more similar to other languages, for example in Java the equivalent code is:

Java generics are a powerful feature that allows you to write more flexible and reusable code. They enable you to define classes, interfaces, and methods with type parameters, which can be specified when you instantiate or invoke them.

Generics help maintain consistency in your code by ensuring that the same type is used throughout a collection or method. This reduces the likelihood of errors and makes the code easier to understand and maintain.

Here are some key benefits of using generics:

Here's a simple example to illustrate the use of Java generics:

In this example, we create two ArrayList instances: one for String objects and another for Integer objects. The use of generics ensures that only the specified type of elements can be added to each list, providing type safety and eliminating the need for explicit casting.

The compiler uses the "< >" syntax in the class name to specify the type of the “generics” arguments.

The Compiler already supports the syntax “&” to concatenate two or more string literals. Starting from the 2025 R1 release concatenation is also supported between data-items, method results and resource strings, making it much more useful and versatile. It allows you to reduce the code that typically requires additional variable definitions and the STRING statement.

For example, the following code snippet:

shows that a string literal is concatenated with a data item, a resource that is declared in the file loaded with the configurations iscobol.resource.file, iscobol.resource.country and iscobol.resource.language and the values returned by the call to the toUpperCase method